package com.zhixue.media.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.j256.simplemagic.ContentInfo;
import com.j256.simplemagic.ContentInfoUtil;
import com.zhixue.base.exception.ZhiXueException;
import com.zhixue.base.model.RestResponse;
import com.zhixue.media.mapper.MediaProcessMapper;
import com.zhixue.media.model.dto.QueryMediaParamsDto;
import com.zhixue.base.model.PageParams;
import com.zhixue.base.model.PageResult;
import com.zhixue.media.mapper.MediaFilesMapper;
import com.zhixue.media.model.dto.UploadFileParamsDto;
import com.zhixue.media.model.dto.UploadFileResultDto;
import com.zhixue.media.model.po.MediaFiles;
import com.zhixue.media.model.po.MediaProcess;
import com.zhixue.media.service.MediaFilesService;
import io.minio.*;
import io.minio.messages.DeleteError;
import io.minio.messages.DeleteObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.compress.utils.IOUtils;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.*;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Future;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * <p>
 * 媒资信息 服务实现类
 * </p>
 *
 * @author Dragon
 * @since 2023-09-25
 */
@Slf4j
@Service
public class MediaFilesServiceImpl extends ServiceImpl<MediaFilesMapper, MediaFiles> implements MediaFilesService {


    @Autowired
    MediaFilesMapper mediaFilesMapper;

    @Autowired
    MediaProcessMapper mediaProcessMapper;

    @Autowired
    MinioClient minioClient;

    @Autowired
    MediaFilesService currentProxy;

    //存储普通文件
    @Value("${minio.bucket.files}")
    private String bucket_mediafiles;

    //存储视频
    @Value("${minio.bucket.videofiles}")
    private String bucket_video;



    /**
     * 媒资列表查询接口
     * @param companyId
     * @param pageParams
     * @param queryMediaParamsDto
     * @return
     */
    @Override
    public PageResult<MediaFiles> queryMediaFiels(Long companyId, PageParams pageParams, QueryMediaParamsDto queryMediaParamsDto) {
        //构建查询条件对象
        LambdaQueryWrapper<MediaFiles> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(!StringUtils.isEmpty(queryMediaParamsDto.getFilename()), MediaFiles::getFilename, queryMediaParamsDto.getFilename());
        queryWrapper.eq(!StringUtils.isEmpty(queryMediaParamsDto.getFileType()), MediaFiles::getFileType, queryMediaParamsDto.getFileType());
        //分页对象
        Page<MediaFiles> page = new Page<>(pageParams.getPageNo(), pageParams.getPageSize());
        // 查询数据内容获得结果
        Page<MediaFiles> pageResult = mediaFilesMapper.selectPage(page, queryWrapper);
        // 获取数据列表
        List<MediaFiles> list = pageResult.getRecords();
        // 获取数据总数
        long total = pageResult.getTotal();
        // 构建结果集
        PageResult<MediaFiles> mediaListResult = new PageResult<>(list, total, pageParams.getPageNo(), pageParams.getPageSize());
        return mediaListResult;
    }



    /**
     * 上传文件
     * @param companyId 机构id
     * @param uploadFileParamsDto 文件信息
     * @param localFilePath 文件本地路径
     * @param objectName  如果传入objectnmae，则要去按照objectname的目录去存储，如果不传则按年月日目录去存储
     * @return  UploadFileResultDto
     */
    //@Transactional  //在方法执行之前开启事务，在方法执行之后提交事务
    @Override
    public UploadFileResultDto uploadFile(Long companyId, UploadFileParamsDto uploadFileParamsDto, String localFilePath ,String objectName) {
        //文件名
        String filename = uploadFileParamsDto.getFilename();
        //先得到扩展名
        String extension = filename.substring(filename.lastIndexOf("."));
        //得到mimeType
        String mimeType = getMimeType(extension);

        //子目录
        String defaultFolderPath = getDefaultFolderPath();
        //文件的md5值
        String fileMd5 = getFileMd5(new File(localFilePath));
        if(StringUtils.isEmpty(objectName)){
            //使用默认的年月日
            objectName = defaultFolderPath+fileMd5+extension;
        }
        //上传文件到minio
        boolean result = addMediaFilesToMinIO(localFilePath, mimeType, bucket_mediafiles, objectName);
        if(!result){
            ZhiXueException.cast("上传文件失败");
        }
        //入库文件信息
        MediaFiles mediaFiles = currentProxy.addMediaFilesToDb(companyId, fileMd5, uploadFileParamsDto, bucket_mediafiles, objectName);
        if(mediaFiles==null){
            ZhiXueException.cast("文件上传后保存信息失败");
        }
        //准备返回的对象
        UploadFileResultDto uploadFileResultDto = new UploadFileResultDto();
        BeanUtils.copyProperties(mediaFiles,uploadFileResultDto);

        return uploadFileResultDto;

    }



    /**
     * 获取文件默认存储目录路径 年/月/日
     */
    private String getDefaultFolderPath() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String folder = sdf.format(new Date()).replace("-", "/")+"/";
        return folder;
    }



    /**
     *  根据扩展名获取mimeType
     */
    private String getMimeType(String extension){
        if(extension == null){
            extension = "";
        }
        //根据扩展名取出mimeType
        ContentInfo extensionMatch = ContentInfoUtil.findExtensionMatch(extension);
        String mimeType = MediaType.APPLICATION_OCTET_STREAM_VALUE;//通用mimeType，字节流
        if(extensionMatch!=null){
            mimeType = extensionMatch.getMimeType();
        }
        return mimeType;

    }



    /**
     * 获取文件的md5
     */
    private String getFileMd5(File file) {
        try (FileInputStream fileInputStream = new FileInputStream(file)) {
            String fileMd5 = DigestUtils.md5Hex(fileInputStream);
            return fileMd5;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }



    /**
     * 上传文件到数据库
     * @param companyId
     * @param fileMd5
     * @param uploadFileParamsDto
     * @param bucket
     * @param objectName
     * @return
     */
    @Transactional
    @Override
    public MediaFiles addMediaFilesToDb(Long companyId, String fileMd5, UploadFileParamsDto uploadFileParamsDto, String bucket, String objectName) {

        //将文件信息保存到数据库
        MediaFiles mediaFiles = mediaFilesMapper.selectById(fileMd5);
        if(mediaFiles == null){
            mediaFiles = new MediaFiles();
            BeanUtils.copyProperties(uploadFileParamsDto,mediaFiles);
            //文件id
            mediaFiles.setId(fileMd5);
            //机构id
            mediaFiles.setCompanyId(companyId);
            //桶
            mediaFiles.setBucket(bucket);
            //file_path
            mediaFiles.setFilePath(objectName);
            //file_id
            mediaFiles.setFileId(fileMd5);
            //url
            mediaFiles.setUrl("/"+bucket+"/"+objectName);
            //上传时间
            mediaFiles.setCreateDate(LocalDateTime.now());
            //状态
            mediaFiles.setStatus("1");
            //审核状态
            mediaFiles.setAuditStatus("002003");
            //插入数据库
            int insert = mediaFilesMapper.insert(mediaFiles);
            if(insert<=0){
                log.debug("向数据库保存文件失败,bucket:{},objectName:{}",bucket,objectName);
                return null;
            }

            //记录待处理任务
            //判断如果是avi格式视频写入待处理任务
            //添加到待处理任务表
            addWaitingTask(mediaFiles);

            //向MediaProcess插入记录


            return mediaFiles;

        }
        return mediaFiles;
    }



    /**
     * 添加待处理任务
     * @param mediaFiles 媒资文件信息
     */
    private void addWaitingTask(MediaFiles mediaFiles){
        //文件名称
        String filename = mediaFiles.getFilename();
        //文件扩展名
        String extension = filename.substring(filename.lastIndexOf("."));
        //文件mimeType
        String mimeType = getMimeType(extension);
        //如果是avi视频添加到视频待处理表
        if(mimeType.equals("video/x-msvideo")){
            MediaProcess mediaProcess = new MediaProcess();
            BeanUtils.copyProperties(mediaFiles,mediaProcess);
            mediaProcess.setStatus("1");//未处理
            mediaProcess.setFailCount(0);//失败次数默认为0
            mediaProcess.setUrl(null);
            mediaProcessMapper.insert(mediaProcess);
        }
    }


    /**
     * 将文件上传到minio
     * @param localFilePath 文件本地路径
     * @param mimeType 媒体类型
     * @param bucket 桶
     * @param objectName 对象名
     * @return
     */
    public boolean addMediaFilesToMinIO(String localFilePath,String mimeType,String bucket, String objectName){
        try {
            UploadObjectArgs uploadObjectArgs = UploadObjectArgs.builder()
                    .bucket(bucket)//桶
                    .filename(localFilePath) //指定本地文件路径
                    .object(objectName)//对象名 放在子目录下
                    .contentType(mimeType)//设置媒体文件类型
                    .build();
            //上传文件
            minioClient.uploadObject(uploadObjectArgs);
            log.debug("上传文件到minio成功,bucket:{},objectName:{}",bucket,objectName);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            log.error("上传文件出错,bucket:{},objectName:{},错误信息:{}",bucket,objectName,e.getMessage());
        }
        return false;
    }



    /**
     * 检查文件是否存在
     * @param fileMd5 文件的md5
     * @return
     */
    @Override
    public RestResponse<Boolean> checkFile(String fileMd5) {
        //数据库不存在的话，minio中一定不存在
        MediaFiles mediaFiles = mediaFilesMapper.selectById(fileMd5);
        // 数据库中不存在，则直接返回false 表示不存在
        if (mediaFiles == null) {
            return RestResponse.success(false);
        }
        // 若数据库中存在，根据数据库中的文件信息，则继续判断bucket中是否存在
        try {
            InputStream inputStream = minioClient.getObject(GetObjectArgs
                    .builder()
                    .bucket(mediaFiles.getBucket())
                    .object(mediaFiles.getFilePath())
                    .build());
            if (inputStream == null) {
                return RestResponse.success(false);
            }
        } catch (Exception e) {
            return RestResponse.success(false);
        }
        return RestResponse.success(true);
    }


    /**
     * 检查分块是否存在
     * @param fileMd5    文件的MD5
     * @param chunkIndex 分块序号
     * @return
     */
    @Override
    public RestResponse<Boolean> checkChunk(String fileMd5, int chunkIndex) {
        // 获取分块目录
        String chunkFileFolderPath = getChunkFileFolderPath(fileMd5);
        String chunkFilePath = chunkFileFolderPath + chunkIndex;
        try {
            // 判断分块是否存在
            InputStream inputStream = minioClient.getObject(GetObjectArgs
                    .builder()
                    .bucket(bucket_video)
                    .object(chunkFilePath)
                    .build());
            // 不存在返回false
            if (inputStream == null) {
                return RestResponse.success(false);
            }
        } catch (Exception e) {
            // 出异常也返回false
            return RestResponse.success(false);
        }
        // 否则返回true
        return RestResponse.success(true);
    }


    /**
     * 获取分块文件的目录，例如文件的md5码为  1f2465f， 那么该文件的分块放在 /1/f/1f2465f下，即前两级目录为md5的前两位
     * @param fileMd5
     * @return
     */
    private String getChunkFileFolderPath(String fileMd5) {
        return fileMd5.substring(0, 1) + "/" + fileMd5.substring(1, 2) + "/" + fileMd5 + "/" + "chunk" + "/";
    }


    /**
     * 上传分块
     * @param fileMd5 文件MD5
     * @param chunkIndex   分块序号
     * @param localChunkFilePath   文件字节
     * @return
     */
    @Override
    public RestResponse uploadChunk(String fileMd5, int chunkIndex, String localChunkFilePath) {
        System.out.println("uploadChunk");
        //前端对文件分块的大小为5MB，SpringBoot web默认上传文件的大小限制为1MB
        //分块文件的路径
        String chunkFilePath=getChunkFileFolderPath(fileMd5) + chunkIndex;
        //获取mineType
        String mineType =getMimeType(null);
        //将分块文件上传到minio
        boolean b = addMediaFilesToMinIO(localChunkFilePath, mineType, bucket_video, chunkFilePath);
        if (!b) {
            log.debug("上传分块文件失败:{}", chunkFilePath);
            return RestResponse.validfail(false, "上传分块失败");
        }
        log.debug("上传分块文件成功:{}",chunkFilePath);
        return RestResponse.success(true);
    }


    /**
     * 合并文件
     * @param companyId           机构id
     * @param fileMd5             文件MD5
     * @param chunkTotal          分块数量
     * @param uploadFileParamsDto 文件信息
     * @return
     * @throws Exception
     */
    @Override
    public RestResponse mergeChunks(Long companyId, String fileMd5, int chunkTotal, UploadFileParamsDto uploadFileParamsDto) throws Exception {

        //分块文件所在目录
        String chunkFileFolderPath = getChunkFileFolderPath(fileMd5);
        //找到所有的分块文件
        List<ComposeSource>sources=new ArrayList<>();
        for (int i = 0; i < chunkTotal; i++) {
            //指定分块文件的信息
            ComposeSource composeSource= ComposeSource
                    .builder()
                    .bucket(bucket_video)
                    .object(chunkFileFolderPath + i)
                    .build();
            sources.add(composeSource);
        }
        //源文件名称
        String filename = uploadFileParamsDto.getFilename();
        //扩展名
        String extension = filename.substring(filename.lastIndexOf("."));
        //合并后文件的objectname
        String objectName = getFilePathByMd5(fileMd5, extension);
        //指定合并后的objectName等信息
        ComposeObjectArgs composeObjectArgs = ComposeObjectArgs.builder()
                .bucket(bucket_video)
                .object(objectName)//合并后的文件的objectname
                .sources(sources)//指定源文件
                .build();


        //===========合并文件============
        //报错size 1048576 must be greater than 5242880，minio默认的分块文件大小为5M
        try {
            minioClient.composeObject(composeObjectArgs);
        } catch (Exception e) {
            e.printStackTrace();
            log.error("合并文件出错,bucket:{},objectName:{},错误信息:{}",bucket_video,objectName,e.getMessage());
            return RestResponse.validfail(false,"合并文件异常");
        }



        //===========校验合并后的和源文件是否一致，视频上传才成功===========
        //先下载合并后的文件
        File file = downloadFileFromMinIO(bucket_video, objectName);
        try(FileInputStream fileInputStream = new FileInputStream(file)){
            //计算合并后文件的md5
            String mergeFile_md5 = DigestUtils.md5Hex(fileInputStream);
            //比较原始md5和合并后文件的md5
            if(!fileMd5.equals(mergeFile_md5)){
                log.error("校验合并文件md5值不一致,原始文件:{},合并文件:{}",fileMd5,mergeFile_md5);
                return RestResponse.validfail(false,"文件校验失败");
            }
            //文件大小
            uploadFileParamsDto.setFileSize(file.length());
        }catch (Exception e) {
            return RestResponse.validfail(false,"文件校验失败");
        }



        //==============将文件信息入库============
        //注意要用代理对象
        MediaFiles mediaFiles = currentProxy.addMediaFilesToDb(companyId, fileMd5, uploadFileParamsDto, bucket_video, objectName);
        if(mediaFiles == null){
            return RestResponse.validfail(false,"文件入库失败");
        }


        //==========清理分块文件=========
        clearChunkFiles(chunkFileFolderPath,chunkTotal);

        return RestResponse.success(true);


    }



    /**
     * 从minio下载文件
     * @param bucket 桶
     * @param objectName 对象名称
     * @return 下载后的文件
     */
    public File downloadFileFromMinIO(String bucket,String objectName){
        //临时文件
        File minioFile = null;
        FileOutputStream outputStream = null;
        try{
            InputStream stream = minioClient.getObject(GetObjectArgs.builder()
                    .bucket(bucket)
                    .object(objectName)
                    .build());
            //创建临时文件
            minioFile=File.createTempFile("minio", ".merge");
            outputStream = new FileOutputStream(minioFile);
            IOUtils.copy(stream,outputStream);
            return minioFile;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(outputStream!=null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }



    /**
     * 清除分块文件
     * @param chunkFileFolderPath 分块文件路径
     * @param chunkTotal 分块文件总数
     */
    private void clearChunkFiles(String chunkFileFolderPath,int chunkTotal) {
        List<DeleteObject> objects = new ArrayList<>();
        for (int i = 0; i < chunkTotal; i++) {
            //指定分块文件的信息
            DeleteObject deleteObject = new DeleteObject(chunkFileFolderPath + i);
            objects.add(deleteObject);
        }
        //Iterable<DeleteObject> objects =  Stream.iterate(0, i -> ++i).limit(chunkTotal).map(i -> new DeleteObject(chunkFileFolderPath+ i)).collect(Collectors.toList());;
        RemoveObjectsArgs removeObjectsArgs = RemoveObjectsArgs
                .builder()
                .bucket(bucket_video)
                .objects(objects)
                .build();
        Iterable<Result<DeleteError>> results = minioClient.removeObjects(removeObjectsArgs);
        //要想真正删除
        for (Result<DeleteError> f : results) {
            try {
                DeleteError deleteError = f.get();
            } catch (Exception e) {
                e.printStackTrace();
            }
            //遍历results对象并针对每个结果执行一些操作。使用f.get()方法可以获得当前结果对象所代表的操作的结果
            //如果该结果表示一个成功的删除操作，则此时返回的结果对象不会产生任何异常
            //如果该结果表示一个失败的删除操作，则此时返回的结果对象将包含相应的错误信息，并会抛出一个包含错误信息的异常。
        }

//        results.forEach(f -> {
//            try {
//                DeleteError deleteError = f.get();
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//        });

    }



    /**
     * 根据MD5和文件扩展名，生成文件路径，例 /2/f/2f6451sdg/2f6451sdg.mp4
     *
     * @param fileMd5   文件MD5
     * @param extension 文件扩展名
     * @return
     */
    public String getFilePathByMd5(String fileMd5, String extension) {
        return fileMd5.substring(0, 1) + "/" + fileMd5.substring(1, 2) + "/" + fileMd5 + "/" + fileMd5 + extension;
    }


    /**
     * 根据媒资id获取媒资信息
     * @param id
     * @return
     */
    @Override
    public MediaFiles getFileById(String id) {
        MediaFiles mediaFiles = mediaFilesMapper.selectById(id);

        return mediaFiles;
    }

























































































































//   以下的方法是与上面合并方式不同的方法，下面的方法是先将文件下载下来，然后合并，接着再将它上传上去，这个方法很笨重
//
//
//
//    /**
//     * 合并分块
//     * @param companyId           机构id
//     * @param fileMd5             文件MD5
//     * @param chunkTotal          分块数量
//     * @param uploadFileParamsDto 文件信息
//     * @return
//     * @throws Exception
//     */
//    @Override
//    public RestResponse mergeChunks(Long companyId, String fileMd5, int chunkTotal, UploadFileParamsDto uploadFileParamsDto) throws Exception {
//        // 下载分块文件
//        File[] chunkFiles = checkChunkStatus(fileMd5, chunkTotal);
//        // 获取源文件名
//        String fileName = uploadFileParamsDto.getFilename();
//        // 获取源文件扩展名
//        String extension = fileName.substring(fileName.lastIndexOf("."));
//        // 创建出临时文件，准备合并
//        File mergeFile = null;
//        try {
//            mergeFile = File.createTempFile(fileName, extension);
//        } catch (IOException e) {
//            ZhiXueException.cast("创建合并临时文件出错");
//        }
//        try {
//            // 缓冲区
//            byte[] buffer = new byte[1024];
//            // 写入流，向临时文件写入
//            try (RandomAccessFile raf_write = new RandomAccessFile(mergeFile, "rw")) {
//                // 遍历分块文件数组
//                for (File chunkFile : chunkFiles) {
//                    // 读取流，读分块文件
//                    try (RandomAccessFile raf_read = new RandomAccessFile(chunkFile, "r")) {
//                        int len;
//                        while ((len = raf_read.read(buffer)) != -1) {
//                            raf_write.write(buffer, 0, len);
//                        }
//                    }
//                }
//            } catch (Exception e) {
//                ZhiXueException.cast("合并文件过程中出错");
//            }
//            uploadFileParamsDto.setFileSize(mergeFile.length());
//
//            // 对文件进行校验，通过MD5值比较
//            try (FileInputStream mergeInputStream = new FileInputStream(mergeFile)) {
//                String mergeMd5 = DigestUtils.md5Hex(mergeInputStream);
//                if (!fileMd5.equals(mergeMd5)) {
//                    ZhiXueException.cast("合并文件校验失败");
//                }
//                log.debug("合并文件校验通过：{}", mergeFile.getAbsolutePath());
//            } catch (Exception e) {
//                ZhiXueException.cast("合并文件校验异常");
//            }
//            String mergeFilePath = getFilePathByMd5(fileMd5, extension);
//
//            // 将本地合并好的文件，上传到minio中，这里重载了一个方法
//            addMediaFilesToMinIO(mergeFile.getAbsolutePath(), null,bucket_video, mergeFilePath);
//            log.debug("合并文件上传至MinIO完成{}", mergeFile.getAbsolutePath());
//
//            // 将文件信息写入数据库
//            MediaFiles mediaFiles = addMediaFilesToDb(companyId, fileMd5, uploadFileParamsDto, mergeFilePath,  bucket_video);
//            if (mediaFiles == null) {
//                ZhiXueException.cast("媒资文件入库出错");
//            }
//            log.debug("媒资文件入库完成");
//            return RestResponse.success();
//        } finally {
//            for (File chunkFile : chunkFiles) {
//                try {
//                    chunkFile.delete();
//                } catch (Exception e) {
//                    log.debug("临时分块文件删除错误：{}", e.getMessage());
//                }
//            }
//            try {
//                mergeFile.delete();
//            } catch (Exception e) {
//                log.debug("临时合并文件删除错误：{}", e.getMessage());
//            }
//        }
//    }
//
//
//
//    /**
//     * 下载分块文件
//     *
//     * @param fileMd5    文件的MD5
//     * @param chunkTotal 总块数
//     * @return 分块文件数组
//     */
//    private File[] checkChunkStatus(String fileMd5, int chunkTotal) {
//        // 作为结果返回
//        File[] files = new File[chunkTotal];
//        // 获取分块文件目录
//        String chunkFileFolder = getChunkFileFolderPath(fileMd5);
//        for (int i = 0; i < chunkTotal; i++) {
//            // 获取分块文件路径
//            String chunkFilePath = chunkFileFolder + i;
//            File chunkFile = null;
//            try {
//                // 创建临时的分块文件
//                chunkFile = File.createTempFile("chunk" + i, null);
//            } catch (Exception e) {
//                ZhiXueException.cast("创建临时分块文件出错：" + e.getMessage());
//            }
//
//            chunkFile = downloadFileFromMinio(chunkFile, bucket_video, chunkFilePath);
//            files[i] = chunkFile;
//        }
//        return files;
//    }
//
//
//    /**
//     * 从Minio中下载文件
//     *
//     * @param file       目标文件
//     * @param bucket     桶
//     * @param objectName 桶内文件路径
//     * @return
//     */
//    public File downloadFileFromMinio(File file, String bucket, String objectName) {
//        try (FileOutputStream fileOutputStream = new FileOutputStream(file);
//             InputStream inputStream = minioClient.getObject(GetObjectArgs
//                     .builder()
//                     .bucket(bucket)
//                     .object(objectName)
//                     .build())) {
//            IOUtils.copy(inputStream, fileOutputStream);
//            return file;
//        } catch (Exception e) {
//            ZhiXueException.cast("查询文件分块出错");
//        }
//        return null;
//    }



}
